package org.jeecg.modules.zhouAdmin.admin.goodsCenter.controller;

import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import org.jeecg.common.api.vo.Result;
import org.jeecg.modules.zhouAdmin.admin.goodsCenter.pojo.*;
import org.jeecg.modules.zhouAdmin.admin.goodsCenter.service.IGoodsCenterService;
import org.jeecgframework.poi.excel.ExcelImportUtil;
import org.jeecgframework.poi.excel.def.NormalExcelConstants;
import org.jeecgframework.poi.excel.entity.ExportParams;
import org.jeecgframework.poi.excel.entity.ImportParams;
import org.jeecgframework.poi.excel.view.JeecgEntityExcelView;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.servlet.ModelAndView;

import java.io.InputStream;
import java.util.List;

@RestController
@RequestMapping("/goodsCenter")
public class GoodsCenterController {

    @Autowired
    IGoodsCenterService service;

    /**
     * 获取商品类型列表
     *
     * @param pageNo   当前页
     * @param pageSize 页面大小
     * @param code     类型编号
     */
    @RequestMapping("/listGoodsTypes")
    public Result<?> listGoodsTypes(@RequestParam(name = "pageNo", defaultValue = "1") int pageNo,
                                    @RequestParam(name = "pageSize", defaultValue = "10") int pageSize,
                                    String code) {
        Page<MlccThirdGoodsType> page = new Page<>(pageNo, pageSize);
        try {
            IPage<MlccThirdGoodsType> iPage = service.listGoodsTypes(page, code);
            return Result.ok(iPage);
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error("系统异常");
        }
    }

    /**
     * 新增商品类型
     *
     * @param goodsType 商品类型对象
     */
    @RequestMapping("/addGoodType")
    public Result<?> addGoodType(MlccThirdGoodsType goodsType) {
        try {
            int i = service.addGoodType(goodsType);
            if (i > 0) {
                return Result.ok("添加成功");
            } else if (i == -1) {
                return Result.error("商品类型名称或编号重复");
            } else {
                return Result.error("添加失败");
            }
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error("添加失败");
        }
    }

    /**
     * 编辑商品类型
     *
     * @param goodsType 商品类型对象
     */
    @RequestMapping("/updateGoodType")
    public Result<?> updateGoodType(MlccThirdGoodsType goodsType) {
        try {
            int i = service.updateGoodType(goodsType);
            if (i > 0) {
                return Result.ok("添加成功");
            } else if (i == -1) {
                return Result.error("商品类型名称或编号重复");
            } else {
                return Result.error("添加失败");
            }
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error("添加失败");
        }
    }

    /**
     * 删除商品类型
     *
     * @param id 商品类型id
     */
    @RequestMapping("/delGoodType")
    public Result<?> delGoodType(String id) {
        try {
            int i = service.delGoodType(id);
            if (i > 0) {
                return Result.ok("添加成功");
            } else {
                return Result.error("添加失败");
            }
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error("添加失败");
        }
    }

    /**
     * 商品类型详情
     *
     * @param id 商品类型id
     */
    @RequestMapping("/typeDetail")
    public Result<?> typeDetail(Integer id) {
        try {
            MlccThirdGoodsType type = service.typeDetail(id);
            return Result.ok(type);
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error("查询失败");
        }
    }

    /**
     * 获取类型下的参数列表
     *
     * @param type 商品类型id
     */
    @RequestMapping("/listTypeParam")
    public Result<?> listTypeParam(String type) {
        try {
            List<MlccThirdGoodstypeParameter> list = service.listTypeParam(type);
            return Result.ok(list);
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error("查询失败");
        }
    }

    /**
     * 新增商品类型参数
     *
     * @param param 参数数组
     * @param type  商品类型id
     */
    @RequestMapping("/saveTypeParam")
    public Result<?> saveTypeParam(MlccThirdGoodstypeParameter param, String type) {
        try {
            int i = service.saveTypeParam(param, type);
            if (i > 0) {
                return Result.ok("操作成功");
            } else if (i == 0) {
                return Result.error("参数已存在");
            } else if (i == -1) {
                return Result.error("最多设置20个参数");
            } else {
                return Result.error("操作失败");
            }
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error("添加失败");
        }
    }

    /**
     * 更新商品类型参数
     *
     * @param param 参数数组
     */
    @RequestMapping("/updateTypeParam")
    public Result<?> updateTypeParam(@RequestBody MlccThirdGoodstypeParameter param) {
        try {
            int i = service.updateTypeParam(param);
            if (i > 0) {
                return Result.ok("操作成功");
            } else {
                return Result.error("操作失败");
            }
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error("添加失败");
        }
    }


    /**
     * 删除商品类型参数
     *
     * @param id 参数id
     */
    @RequestMapping("/delTypeParam")
    public Result<?> delTypeParam(String id) {
        try {
            int i = service.delTypeParam(id);
            if (i > 0) {
                return Result.ok("操作成功");
            } else {
                return Result.error("操作失败");
            }
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error("添加失败");
        }
    }
    /*------------------------------商品维护----------------------------------*/

    /**
     * 获取商品类型的下拉列表
     */
    @RequestMapping("/laGoodsType")
    public JSONObject laGoodsType() {
        JSONObject jsonObject = new JSONObject();
        try {
            List<MlccThirdGoodsType> goodsTypes = service.laGoodsType();
            jsonObject.put("code", 0);
            jsonObject.put("data", goodsTypes);
        } catch (Exception e) {
            e.printStackTrace();
            jsonObject.put("code", 1);
            jsonObject.put("msg", "查询失败");
        }
        return jsonObject;
    }

    /**
     * 商品系列列表
     *
     * @param pageNo
     * @param pageSize
     * @param typeid   商品类型
     * @param name     系列名称
     * @param status   状态
     */
    @RequestMapping("/listGoodsGroup")
    public Result<?> listGoodsGroup(@RequestParam(name = "pageNo", defaultValue = "1") int pageNo,
                                    @RequestParam(name = "pageSize", defaultValue = "10") int pageSize,
                                    String typeid, String name, Integer status) {
        Page<MlccThirdGoodsSeries> page = new Page<>(pageNo, pageSize);
        try {
            IPage<MlccThirdGoodsSeries> iPage = service.listGoodsGroup(page, typeid, name, status);
            return Result.ok(iPage);
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error("系统异常");
        }
    }

    /**
     * 新增商品系列
     *
     * @param entity 商品系列对象
     */
    @RequestMapping("/addGoodGroup")
    public Result<?> addGoodGroup(MlccThirdGoodsSeries entity) {
        try {
            int i = service.addGoodGroup(entity);
            if (i > 0) {
                return Result.ok("添加成功");
            } else {
                return Result.error("添加失败");
            }
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error("添加失败");
        }
    }

    /**
     * 编辑商品系列
     *
     * @param entity 商品系列对象
     */
    @RequestMapping("/updateGoodGroup")
    public Result<?> updateGoodGroup(MlccThirdGoodsSeries entity) {
        try {
            int i = service.updateGoodGroup(entity);
            if (i > 0) {
                return Result.ok("添加成功");
            } else {
                return Result.error("添加失败");
            }
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error("添加失败");
        }
    }

    /**
     * 下架商品系列
     *
     * @param id 商品系列id
     */
    @RequestMapping("/offGoodGroup")
    public Result<?> offGoodGroup(String id) {
        try {
            int i = service.offGoodGroup(id);
            if (i > 0) {
                return Result.ok("下架成功");
            } else {
                return Result.error("下架失败");
            }
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error("系统异常");
        }
    }

    /**
     * 上架商品系列
     *
     * @param id 商品系列id
     */
    @RequestMapping("/upGoodGroup")
    public Result<?> upGoodGroup(String id) {
        try {
            int i = service.upGoodGroup(id);
            if (i > 0) {
                return Result.ok("上架成功");
            } else {
                return Result.error("上架失败");
            }
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error("系统异常");
        }
    }

    /**
     * 删除商品系列
     *
     * @param id 商品系列id
     */
    @RequestMapping("/delGoodGroup")
    public Result<?> delGoodGroup(String id) {
        try {
            int i = service.delGoodGroup(id);
            if (i > 0) {
                return Result.ok("删除成功");
            } else if (i == -1) {
                return Result.error("上架中的系列无法删除，请先下架");
            } else {
                return Result.error("删除失败");
            }
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error("系统异常");
        }
    }

    /**
     * 获取商品系列的阶梯售价
     *
     * @param groupid 商品系列ID
     */
    @RequestMapping("/listGroupPrice")
    public JSONObject listGroupPrice(String groupid) {
        JSONObject jsonObject = new JSONObject();
        try {
            List<MlccThirdGoodsRange> ladderPrices = service.listGroupPrice(groupid);
            jsonObject.put("code", 0);
            jsonObject.put("data", ladderPrices);
        } catch (Exception e) {
            e.printStackTrace();
            jsonObject.put("code", 1);
            jsonObject.put("msg", "查询失败");
        }
        return jsonObject;
    }

    /**
     * 添加阶梯售价
     *
     * @param entity 参数对象
     */
    @RequestMapping("/saveGroupPrice")
    public JSONObject saveGroupPrice(MlccThirdGoodsRange entity) {
        JSONObject jsonObject = new JSONObject();
        try {
            int results = service.saveGroupPrice(entity);
            if (results > 0) {
                jsonObject.put("code", 0);
                jsonObject.put("msg", "添加成功");
            } else if (results == -1) {
                jsonObject.put("code", 1);
                jsonObject.put("msg", "区间与其他区间冲突，请检查");
            } else {
                jsonObject.put("code", 1);
                jsonObject.put("msg", "添加失败");
            }
        } catch (Exception e) {
            e.printStackTrace();
            jsonObject.put("code", 1);
            jsonObject.put("msg", "发生异常");
        }
        return jsonObject;
    }

    /**
     * 删除商品系列阶梯价
     *
     * @param id 阶梯价主键id
     */
    @RequestMapping("/deleteGroupPrice")
    public JSONObject deleteGroupPrice(String id) {
        JSONObject jsonObject = new JSONObject();
        try {
            int results = service.deleteGroupPrice(id);
            if (results > 0) {
                jsonObject.put("code", 0);
                jsonObject.put("msg", "删除成功");
            } else {
                jsonObject.put("code", 1);
                jsonObject.put("msg", "操作失败");
            }
        } catch (Exception e) {
            e.printStackTrace();
            jsonObject.put("code", 1);
            jsonObject.put("msg", "发生异常");
        }
        return jsonObject;
    }

    /**
     * 获取商品列表
     *
     * @param pageNo
     * @param pageSize
     * @param code     商品编号
     * @param gyscode  供应商编号
     * @param status   状态
     */
    @RequestMapping("/listGoods")
    public Result<?> listGoods(@RequestParam(name = "pageNo", defaultValue = "1") int pageNo,
                               @RequestParam(name = "pageSize", defaultValue = "10") int pageSize,
                               String code, String gysCode, Integer status, String groupID) {
        Page<MlccThirdGoods> page = new Page<>(pageNo, pageSize);
        try {
            IPage<MlccThirdGoods> iPage = service.listGoods(page, code, gysCode, status, groupID);
            return Result.ok(iPage);
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error("系统异常");
        }
    }

    /**
     * 下架商品
     *
     * @param id 商品id
     */
    @RequestMapping("/offGoods")
    public Result<?> offGoods(String id) {
        try {
            int i = service.offGoods(id);
            if (i > 0) {
                return Result.ok("下架成功");
            } else {
                return Result.error("下架失败");
            }
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error("系统异常");
        }
    }

    /**
     * 上架商品
     *
     * @param id 商品id
     */
    @RequestMapping("/upGoods")
    public Result<?> upGoods(String id) {
        try {
            int i = service.upGoods(id);
            if (i > 0) {
                return Result.ok("上架成功");
            } else {
                return Result.error("上架失败");
            }
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error("系统异常");
        }
    }

    /**
     * 删除商品
     *
     * @param id 商品id
     */
    @RequestMapping("/delGoods")
    public Result<?> delGoods(String id) {
        try {
            int i = service.delGoods(id);
            if (i > 0) {
                return Result.ok("删除成功");
            } else if (i == -1) {
                return Result.error("上架中的商品无法删除，请先下架");
            } else {
                return Result.error("删除失败");
            }
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error("系统异常");
        }
    }

    /*---------------------------商品册-------------------------------*/

    /**
     * 获取商品册列表
     *
     * @param pageNo
     * @param pageSize
     * @param name     商品册名称
     * @param phone    电话
     */
    @RequestMapping("/listBooklets")
    public Result<?> listBooklets(@RequestParam(name = "pageNo", defaultValue = "1") int pageNo,
                                  @RequestParam(name = "pageSize", defaultValue = "10") int pageSize,
                                  String name, String phone) {
        Page<MlccThirdGoodsBooklet> page = new Page<>(pageNo, pageSize);
        try {
            IPage<MlccThirdGoodsBooklet> booklets = service.listBooklets(page, name, phone);
            return Result.ok(booklets);
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error("查询失败");
        }
    }

    /**
     * 新增商品册
     *
     * @param booklet 商品册对象
     */
    @RequestMapping("/saveBooklet")
    public Result<?> saveBooklet(MlccThirdGoodsBooklet booklet) {
        try {
            int results = service.saveBooklet(booklet);
            if (results > 0) {
                return Result.ok("添加成功");
            }
            return Result.error("添加失败");
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error("发生异常");
        }
    }

    /**
     * 更新商品册
     *
     * @param booklet 商品册对象
     */
    @RequestMapping("/updateBooklet")
    public Result<?> updateBooklet(@RequestBody MlccThirdGoodsBooklet booklet) {
        try {
            int results = service.updateBooklet(booklet);
            if (results > 0) {
                return Result.ok("操作成功");
            }
            return Result.error("操作失败");
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error("发生异常");
        }
    }

    /**
     * 商品册发放情况
     *
     * @param bookletid 商品册id
     */
    @RequestMapping("/listFafang")
    public Result<?> listFafang(@RequestParam(name = "pageNo", defaultValue = "1") int pageNo,
                                @RequestParam(name = "pageSize", defaultValue = "4") int pageSize, String bookletid) {
        Page<MlccThirdGoodsBookletFa> page = new Page<>(pageNo, pageSize);
        return Result.ok(service.listFafang(bookletid, page));
    }

    /**
     * 商品册详情
     *
     * @param id 商品册id
     */
    @RequestMapping("/bookletDetail")
    public JSONObject bookletDetail(String id) {
        JSONObject jsonObject = new JSONObject();
        try {
            MlccThirdGoodsBooklet results = service.bookletDetail(id);
            jsonObject.put("code", 0);
            jsonObject.put("data", results);
        } catch (Exception e) {
            e.printStackTrace();
            jsonObject.put("code", 1);
            jsonObject.put("msg", "发生异常");
        }
        return jsonObject;
    }

    /**
     * 发放商品册
     *
     * @param bookletid  商品册id
     * @param remark     备注
     * @param num        发放数量
     * @param companyids 公司id
     */
    @RequestMapping("/addFa")
    public Result<?> addFa(String bookletid, String remark, Integer num, String[] companyids) {
        try {
            int results = service.addFa(bookletid, remark, num, companyids);
            if (results > 0) {
                return Result.ok("操作成功");
            }
            return Result.error("操作失败");
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error(e.getMessage());
        }
    }

    /**
     * 删除发放记录
     *
     * @param id 发放id
     */
    @RequestMapping("/deleteFa")
    public Result<?> deleteFa(String id) {
        try {
            int results = service.deleteFa(id);
            if (results > 0) {
                return Result.ok("操作成功");
            }
            return Result.error("操作失败");
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error(e.getMessage());
        }
    }

    /**
     * 获取商品册下的商品列表
     *
     * @param pageNo    分页
     * @param pageSize  页面大小
     * @param bookletid 商品册id
     */
    @RequestMapping("/listFabricFromBooklet")
    public Result<?> listFabricFromBooklet(@RequestParam(name = "pageNo", defaultValue = "1") int pageNo,
                                           @RequestParam(name = "pageSize", defaultValue = "10") int pageSize, String bookletid) {
        Page<MlccThirdGoods> page = new Page<>();
        return Result.ok(service.listFabricFromBooklet(page, bookletid));
    }

    /**
     * 删除商品册下的商品（删除关联信息）
     *
     * @param id 关联表id
     */
    @RequestMapping("/delFabricFrombook")
    public Result<?> delFabricFrombook(String id) {
        try {
            int results = service.delFabricFrombook(id);
            if (results > 0) {
                return Result.ok("操作成功");
            }
            return Result.error("操作失败");
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error("发生异常");
        }
    }

    /*-----------------------主推商品-------------------*/

    /**
     * 获取主推商品列表
     *
     * @param pageNo   当前页
     * @param pageSize 页面大小
     * @param code     商品编号
     * @param gysCode  供应商编号
     * @param status   状态
     */
    @RequestMapping("/getFirstGoodsList")
    public Result<?> getFirstGoodsList(@RequestParam(name = "pageNo", defaultValue = "1") int pageNo,
                                       @RequestParam(name = "pageSize", defaultValue = "10") int pageSize,
                                       String code, String gysCode, String status) {
        Page<MlccThirdGoods> page = new Page<>(pageNo, pageSize);
        try {
            IPage<MlccThirdGoods> list = service.getFirstGoodsList(page, code, gysCode, status);
            return Result.ok(list);
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error("查询失败");
        }
    }

    /**
     * 新增主推商品
     *
     * @param code   商品编号
     * @param price  添加的价格
     * @param remark 备注
     */
    @RequestMapping("/addFirstGoods")
    public Result<?> addFirstGoods(String code, double price, String remark) {
        try {
            int result = service.addFirstGoods(code, price, remark);
            if (result == -1) {
                return Result.error("商品不存在");
            } else if (result > 0) {
                return Result.ok("添加成功");
            } else {
                return Result.ok("添加失败");
            }

        } catch (Exception e) {
            e.printStackTrace();
            return Result.ok("添加失败");
        }
    }

    /**
     * 根据商品系例获取配置的参数
     *
     * @param groupid 商品系列id
     */
    @RequestMapping("/paramlist")
    public Result<?> paramlist(String groupid) {
        try {
            List<MlccThirdGoodstypeParameter> paramlist = service.paramlist(groupid);
            return Result.ok(paramlist);
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error("查询失败");
        }
    }

    /**
     * 根据商品系列获取商品类型
     *
     * @param group 商品系列id
     */
    @RequestMapping("/goodsTypeByGroup")
    public Result<?> goodsTypeByGroup(String group) {
        try {
            MlccThirdGoodsType goodsType = service.goodsTypeByGroup(group);
            return Result.ok(goodsType);
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error("查询失败");
        }
    }

    /**
     * 进入新增商品界面，创建一条未启用的商品
     *
     * @param group 商品系列id
     */
    @RequestMapping("/createGoods")
    public Result<?> createGoods(String group) {
        try {
            String goodsid = service.createGoods(group);
            return Result.ok(goodsid);
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error(e.getMessage());
        }
    }

    /**
     * 给商品设置参数
     *
     * @param parameterId 参数id
     * @param paramvalue  参数值
     * @param goodsid     商品id
     */
    @RequestMapping("/saveGoodsParam")
    public Result<?> saveGoodsParam(String parameterId, String paramvalue, String goodsid) {
        try {
            int results = service.saveGoodsParam(parameterId, paramvalue, goodsid);
            if (results > 0) {
                return Result.ok("操作成功");
            } else if (results == -1) {
                return Result.error("参数已存在");
            } else {
                return Result.error("操作失败");
            }
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error("发生异常");
        }
    }

    /**
     * 保存商品返修项
     *
     * @param fanxiu 返修项
     */
    @RequestMapping("/saveFanxiu")
    public Result<?> saveFanxiu(MlccThirdGoodsFanxiu fanxiu) {
        try {
            int results = service.saveFanxiu(fanxiu);
            if (results > 0) {
                return Result.ok("操作成功");
            } else if (results == -1) {
                return Result.error("参数已存在");
            } else {
                return Result.error("操作失败");
            }
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error("发生异常");
        }
    }

    /**
     * 获取商品已设置的返修参数
     *
     * @param goodsid 商品id
     */
    @RequestMapping("/listFanxiu")
    public Result<?> listFanxiu(String goodsid) {
        try {
            List<MlccThirdGoodsFanxiu> list = service.listFanxiu(goodsid);
            return Result.ok(list);
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error("发生异常");
        }
    }

    /**
     * 删除返修参数
     *
     * @param id 返修id
     */
    @RequestMapping("/delFanxiu")
    public Result<?> delFanxiu(String id) {
        try {
            int results = service.delFanxiu(id);
            if (results > 0) {
                return Result.ok("操作成功");
            } else {
                return Result.error("操作失败");
            }
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error("发生异常");
        }
    }

    /*--------------------商品规格------------------------*/

    /**
     * 商品导入规格excel
     *
     * @param file    上传的Excel文件
     * @param goodsid 商品ID
     */
    @PostMapping("/importguigeExcel")
    public JSONObject importguigeExcel(MultipartFile file, String goodsid) throws Exception {
        JSONObject jsonObject = new JSONObject();
        ImportParams params = new ImportParams();
        //表格标题所在行，计数从0开始
        params.setTitleRows(1);
        //head头部所在行，计数从0开始
        params.setHeadRows(1);
        //表格sheet数量
        //params.setSheetNum(9);
        // 最好不要设置为true，否则导入一次excel服务器会重启一次，原因不明
        //params.setNeedSave(true);
        System.out.println(file + "=====================");
        InputStream inputStream = file.getInputStream();
        List<MlccThirdGoodsSpecifications> list = ExcelImportUtil.importExcel(inputStream, MlccThirdGoodsSpecifications.class, params);
        int result = service.importExcel(list, goodsid);
        if (result > 0) {
            jsonObject.put("code", 0);
            jsonObject.put("msg", "导入成功");
        } else {
            jsonObject.put("code", 500);
            jsonObject.put("message", "文件中存在重复面料");
        }
        return jsonObject;
    }

    /**
     * 获取商品规格模板
     */
    @RequestMapping("/exportGuige")
    public ModelAndView exportGuige() {
        ModelAndView mv = new ModelAndView(new JeecgEntityExcelView());
        //导出文件名称
        mv.addObject(NormalExcelConstants.FILE_NAME, "商品规格模板");
        //注解对象Class
        mv.addObject(NormalExcelConstants.CLASS, MlccThirdGoodsSpecifications.class);
        //自定义表格参数
        mv.addObject(NormalExcelConstants.PARAMS, new ExportParams("商品规格模板", "商品规格模板"));
        //导出数据列表
        mv.addObject(NormalExcelConstants.DATA_LIST, service.exportGuige());
        return mv;
    }

    /**
     * 查询已经设置的商品规格
     *
     * @param goodsid 商品id
     */
    @RequestMapping("/listGuige")
    public Result<?> listGuige(String goodsid) {
        try {
            List<MlccThirdGoodsSpecifications> list = service.listGuige(goodsid);
            return Result.ok(list);
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error("发生异常");
        }
    }

    /**
     * 删除已经设置的商品规格
     *
     * @param id 规格id
     */
    @RequestMapping("/delGuige")
    public Result<?> delGuige(String id) {
        try {
            int result = service.delGuige(id);
            return Result.ok("操作成功");
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error("发生异常");
        }
    }

    /*--------------------商品尺码------------------------*/

    /**
     * 商品导入尺码excel
     *
     * @param file    上传的Excel文件
     * @param goodsid 商品ID
     */
    @PostMapping("/importSizeExcel")
    public JSONObject importSizeExcel(MultipartFile file, String goodsid) throws Exception {
        JSONObject jsonObject = new JSONObject();
        ImportParams params = new ImportParams();
        //表格标题所在行，计数从0开始
        params.setTitleRows(1);
        //head头部所在行，计数从0开始
        params.setHeadRows(1);
        //表格sheet数量
        //params.setSheetNum(9);
        // 最好不要设置为true，否则导入一次excel服务器会重启一次，原因不明
        //params.setNeedSave(true);
        InputStream inputStream = file.getInputStream();
        List<MlccThirdGoodsSize> list = ExcelImportUtil.importExcel(inputStream, MlccThirdGoodsSize.class, params);
        int result = service.importSizeExcel(list, goodsid);
        if (result > 0) {
            jsonObject.put("code", 0);
            jsonObject.put("msg", "导入成功");
        } else {
            jsonObject.put("code", 500);
            jsonObject.put("message", "文件中存在重复面料");
        }
        return jsonObject;
    }

    /**
     * 获取商品尺码模板
     */
    @RequestMapping("/exportSize")
    public ModelAndView exportSize() {
        ModelAndView mv = new ModelAndView(new JeecgEntityExcelView());
        //导出文件名称
        mv.addObject(NormalExcelConstants.FILE_NAME, "商品尺码模板");
        //注解对象Class
        mv.addObject(NormalExcelConstants.CLASS, MlccThirdGoodsSize.class);
        //自定义表格参数
        mv.addObject(NormalExcelConstants.PARAMS, new ExportParams("商品尺码模板", "商品尺码模板"));
        //导出数据列表
        mv.addObject(NormalExcelConstants.DATA_LIST, service.exportSize());
        return mv;
    }

    /**
     * 查询已经设置的商品尺码
     *
     * @param goodsid 商品id
     */
    @RequestMapping("/listSize")
    public Result<?> listSize(String goodsid) {
        try {
            List<MlccThirdGoodsSize> list = service.listSize(goodsid);
            return Result.ok(list);
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error("发生异常");
        }
    }

    /**
     * 删除已经设置的商品尺码
     *
     * @param id 尺码id
     */
    @RequestMapping("/delSize")
    public Result<?> delSize(String id) {
        try {
            int result = service.delSize(id);
            return Result.ok("操作成功");
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error("发生异常");
        }
    }

    /**
     * 更新商品
     *
     * @param goods 商品对象
     */
    @RequestMapping("/updateGoods")
    public Result<?> updateGoods(MlccThirdGoods goods) {
        try {
            int results = service.updateGoods(goods);
            if (results > 0) {
                return Result.ok("操作成功");
            } else if (results == -1) {
                return Result.error("商品编号重复,请重新设置商品编号");
            } else if (results == -2) {
                return Result.error("版号不存在，请输入正确的版号编号");
            } else {
                return Result.error("操作失败");
            }
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error("发生异常");
        }
    }

    /**
     * 获取商品详情
     *
     * @param id 商品id
     */
    @RequestMapping("/goodsDetail")
    public Result<?> goodsDetail(String id) {
        try {
            MlccThirdGoods goods = service.goodsDetail(id);
            return Result.ok(goods);
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error("发生异常");
        }
    }

    /**
     * 获取商品配置的参数
     *
     * @param id 商品id
     */
    @RequestMapping("/goodsParam")
    public Result<?> goodsParam(String id) {
        try {
            List<MlccThirdGoodsandparameter> list = service.goodsParam(id);
            return Result.ok(list);
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error("发生异常");
        }
    }

    /**
     * 编辑商品参数
     *
     * @param param 参数对象
     */
    @PostMapping("/updateGoodsParam")
    public Result<?> updateGoodsParam(@RequestBody MlccThirdGoodsandparameter param) {
        System.out.println(param);
        try {
            int results = service.updateGoodsParam(param);
            if (results > 0) {
                return Result.ok("操作成功");
            } else {
                return Result.error("操作失败");
            }
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error("发生异常");
        }
    }

    /**
     * 获取商品列表（导出）
     *
     * @param code    商品编号
     * @param gyscode 供应商编号
     * @param status  状态
     */
    @RequestMapping("/exportGoods")
    public ModelAndView exportGoods(String code, String gyscode, Integer status, String groupID) {
        ModelAndView mv = new ModelAndView(new JeecgEntityExcelView());
        //导出文件名称
        mv.addObject(NormalExcelConstants.FILE_NAME, "商品列表");
        //注解对象Class
        mv.addObject(NormalExcelConstants.CLASS, MlccThirdGoods.class);
        //自定义表格参数
        mv.addObject(NormalExcelConstants.PARAMS, new ExportParams("商品列表", "商品列表"));
        //导出数据列表
        mv.addObject(NormalExcelConstants.DATA_LIST, service.exportGoods(code, gyscode, status, groupID));
        return mv;
    }

    /**
     * 商品导入
     *
     * @param file  上传的Excel文件
     * @param group 商品系列id
     */
    @PostMapping("/importGoods")
    public JSONObject importGoods(MultipartFile file, String group) throws Exception {
        JSONObject jsonObject = new JSONObject();
        ImportParams params = new ImportParams();
        //表格标题所在行，计数从0开始
        params.setTitleRows(1);
        //head头部所在行，计数从0开始
        params.setHeadRows(1);
        //表格sheet数量
        //params.setSheetNum(9);
        // 最好不要设置为true，否则导入一次excel服务器会重启一次，原因不明
        //params.setNeedSave(true);
        InputStream inputStream = file.getInputStream();
        List<MlccThirdGoods> list = ExcelImportUtil.importExcel(inputStream, MlccThirdGoods.class, params);
        int result = service.importGoods(list, group);
        if (result > 0) {
            jsonObject.put("code", 0);
            jsonObject.put("msg", "导入成功");
        } else {
            jsonObject.put("code", 500);
            jsonObject.put("message", "文件中存在重复面料");
        }
        return jsonObject;
    }

    /**
     * 获取商品参数模板（导出）
     *
     * @param groupID 系列id
     */
    @RequestMapping("/exportGoodsParam")
    public ModelAndView exportGoodsParam(String groupID) {
        ModelAndView mv = new ModelAndView(new JeecgEntityExcelView());
        //导出文件名称
        mv.addObject(NormalExcelConstants.FILE_NAME, "商品参数模板");
        //注解对象Class
        mv.addObject(NormalExcelConstants.CLASS, GoodsParamExcel.class);
        //自定义表格参数
        mv.addObject(NormalExcelConstants.PARAMS, new ExportParams("商品参数模板", "商品参数模板"));
        //导出数据列表
        mv.addObject(NormalExcelConstants.DATA_LIST, service.exportGoodsParam(groupID));
        return mv;
    }

    /**
     * 商品参数导入
     *
     * @param file 上传的Excel文件
     */
    @PostMapping("/importGoodsParam")
    public JSONObject importGoodsParam(MultipartFile file) throws Exception {
        JSONObject jsonObject = new JSONObject();
        ImportParams params = new ImportParams();
        //表格标题所在行，计数从0开始
        params.setTitleRows(1);
        //head头部所在行，计数从0开始
        params.setHeadRows(1);
        //表格sheet数量
        //params.setSheetNum(9);
        // 最好不要设置为true，否则导入一次excel服务器会重启一次，原因不明
        //params.setNeedSave(true);
        InputStream inputStream = file.getInputStream();
        List<GoodsParamExcel> list = ExcelImportUtil.importExcel(inputStream, GoodsParamExcel.class, params);
        int result = service.importGoodsParam(list);
        if (result > 0) {
            jsonObject.put("code", 0);
            jsonObject.put("msg", "导入成功");
        } else {
            jsonObject.put("code", 500);
            jsonObject.put("message", "文件中存在重复面料");
        }
        return jsonObject;
    }


    /**
     * 商品册导入商品(把已有的商品加入商品册)
     *
     * @param file      上传的Excel文件
     * @param bookletid 商品册id
     */
    @PostMapping("/importGoodstoBooklet")
    public JSONObject importGoodstoBooklet(MultipartFile file, String bookletid) throws Exception {
        JSONObject jsonObject = new JSONObject();
        ImportParams params = new ImportParams();
        //表格标题所在行，计数从0开始
        params.setTitleRows(1);
        //head头部所在行，计数从0开始
        params.setHeadRows(1);
        //表格sheet数量
        //params.setSheetNum(9);
        // 最好不要设置为true，否则导入一次excel服务器会重启一次，原因不明
        //params.setNeedSave(true);
        InputStream inputStream = file.getInputStream();
        List<MlccThirdGoods> list = ExcelImportUtil.importExcel(inputStream, MlccThirdGoods.class, params);
        int result = service.importGoodstoBooklet(list, bookletid);
        if (result > 0) {
            jsonObject.put("code", 0);
            jsonObject.put("msg", "导入成功");
        } else {
            jsonObject.put("code", 500);
            jsonObject.put("message", "商品已存在，请勿重复导入");
        }
        return jsonObject;
    }
}
